<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>class类继承</title>
</head>

<body>
  <script>
    /* 
      super的用法
      1.super()方法相当于父类的构造函数
      2.只有在子类的构造函数中才能调用super()方法
      3.如果子类显式地定义了构造函数，那么必须调用super()方法，否则报错。
      4.如果子类没有定义构造函数，那么会自动调用super()
      5.当子类的构造函数显式地返回一个对象时，就能避免调用super方法。
      6.在使用this之前，必须先调用super()方法。
    */
    
    class People1 {
      constructor() {
        this.age = 28
      }
      getAge() {
        return this.age
      }
      // 静态方法 类对象才能调用 实例对象不能调用
      static getName() {
        return "strick"
      }
    }

    class Man1 extends People1 {
      constructor() {
        super()      // 返回继承之后的Man对象
        console.log(this.age)     // 先调用super()方法 this才有用

        /* 
          置空Man对象，所有方法和属性都清空（第五点）
          但是不会清空父类People
          return {}
        */     
      }
    }

    var man1 = new Man1()
    console.log(Man1.getName())
    // console.log(man1.getName())     // 报错 静态方法 实例对象不能调用
    // console.log(man1.getAge())

    /* 
      super作为对象使用时，
      1.在子类的原型方法中使用super，那么super指向父类的原型
      2.在子类的静态方法中使用super，那么super指向父类

      简而言之
      static 找 static
      没有的就是找原型链
    */

    class People2 {
      getAge() {
        return 28
      }
      static getAge() {
        return 30
      }
      getName() {
        return "freedom"
      }
      static getName() {
        return "strick"
      }
    }

    class Man2 extends People2 {
      get age() {
        return super.getAge()
      }

      static get name() {
        return super.getName()
      }
    }

    var man2 = new Man2()
    console.log(man2.age)
    console.log(Man2.name)
  </script>
</body>

</html>